// **********************************************************************
//
// Copyright (c) 2003-2008 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

// Ice version 3.3.0
// Generated from file `Define.ice'

#if __MonoCS__

using _System = System;
using _Microsoft = Microsoft;
#else

using _System = global::System;
using _Microsoft = global::Microsoft;
#endif

namespace com
{
    namespace ec
    {
        namespace service
        {
            public struct DateTime
            {
                #region Slice data members

                public short year;

                public short month;

                public short day;

                public short hour;

                public short minute;

                public short second;

                #endregion

                #region Constructor

                public DateTime(short year, short month, short day, short hour, short minute, short second)
                {
                    this.year = year;
                    this.month = month;
                    this.day = day;
                    this.hour = hour;
                    this.minute = minute;
                    this.second = second;
                }

                #endregion

                #region Object members

                public override int GetHashCode()
                {
                    int h__ = 0;
                    h__ = 5 * h__ + year.GetHashCode();
                    h__ = 5 * h__ + month.GetHashCode();
                    h__ = 5 * h__ + day.GetHashCode();
                    h__ = 5 * h__ + hour.GetHashCode();
                    h__ = 5 * h__ + minute.GetHashCode();
                    h__ = 5 * h__ + second.GetHashCode();
                    return h__;
                }

                public override bool Equals(object other__)
                {
                    if(!(other__ is DateTime))
                    {
                        return false;
                    }
                    DateTime o__ = (DateTime)other__;
                    if(!year.Equals(o__.year))
                    {
                        return false;
                    }
                    if(!month.Equals(o__.month))
                    {
                        return false;
                    }
                    if(!day.Equals(o__.day))
                    {
                        return false;
                    }
                    if(!hour.Equals(o__.hour))
                    {
                        return false;
                    }
                    if(!minute.Equals(o__.minute))
                    {
                        return false;
                    }
                    if(!second.Equals(o__.second))
                    {
                        return false;
                    }
                    return true;
                }

                #endregion

                #region Comparison members

                public static bool operator==(DateTime lhs__, DateTime rhs__)
                {
                    return Equals(lhs__, rhs__);
                }

                public static bool operator!=(DateTime lhs__, DateTime rhs__)
                {
                    return !Equals(lhs__, rhs__);
                }

                #endregion

                #region Marshalling support

                public void write__(IceInternal.BasicStream os__)
                {
                    os__.writeShort(year);
                    os__.writeShort(month);
                    os__.writeShort(day);
                    os__.writeShort(hour);
                    os__.writeShort(minute);
                    os__.writeShort(second);
                }

                public void read__(IceInternal.BasicStream is__)
                {
                    year = is__.readShort();
                    month = is__.readShort();
                    day = is__.readShort();
                    hour = is__.readShort();
                    minute = is__.readShort();
                    second = is__.readShort();
                }

                #endregion
            }

            public interface ProductService : Ice.Object, ProductServiceOperations_, ProductServiceOperationsNC_
            {
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public interface ProductServicePrx : Ice.ObjectPrx
            {
                com.ec.service.DateTime[] getTimes();
                com.ec.service.DateTime[] getTimes(_System.Collections.Generic.Dictionary<string, string> context__);

                com.ec.service.DateTime getCurrentDate();
                com.ec.service.DateTime getCurrentDate(_System.Collections.Generic.Dictionary<string, string> context__);

                void printCurrentDate(com.ec.service.DateTime currentDate);
                void printCurrentDate(com.ec.service.DateTime currentDate, _System.Collections.Generic.Dictionary<string, string> context__);

                void printString(string s);
                void printString(string s, _System.Collections.Generic.Dictionary<string, string> context__);

                string[] queryBySql(string sql);
                string[] queryBySql(string sql, _System.Collections.Generic.Dictionary<string, string> context__);

                string[] queryBySqlNotType(string sql);
                string[] queryBySqlNotType(string sql, _System.Collections.Generic.Dictionary<string, string> context__);

                bool addDirectory(int parentid, float tax, string dirName);
                bool addDirectory(int parentid, float tax, string dirName, _System.Collections.Generic.Dictionary<string, string> context__);

                bool updateDirectory(int id, string dirName, float tax);
                bool updateDirectory(int id, string dirName, float tax, _System.Collections.Generic.Dictionary<string, string> context__);
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public interface ProductServiceOperations_
            {
                com.ec.service.DateTime[] getTimes(Ice.Current current__);

                com.ec.service.DateTime getCurrentDate(Ice.Current current__);

                void printCurrentDate(com.ec.service.DateTime currentDate, Ice.Current current__);

                void printString(string s, Ice.Current current__);

                string[] queryBySql(string sql, Ice.Current current__);

                string[] queryBySqlNotType(string sql, Ice.Current current__);

                bool addDirectory(int parentid, float tax, string dirName, Ice.Current current__);

                bool updateDirectory(int id, string dirName, float tax, Ice.Current current__);
            }

            public interface ProductServiceOperationsNC_
            {
                com.ec.service.DateTime[] getTimes();

                com.ec.service.DateTime getCurrentDate();

                void printCurrentDate(com.ec.service.DateTime currentDate);

                void printString(string s);

                string[] queryBySql(string sql);

                string[] queryBySqlNotType(string sql);

                bool addDirectory(int parentid, float tax, string dirName);

                bool updateDirectory(int id, string dirName, float tax);
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public sealed class DateTimeArrayHelper
            {
                public static void write(IceInternal.BasicStream os__, com.ec.service.DateTime[] v__)
                {
                    if(v__ == null)
                    {
                        os__.writeSize(0);
                    }
                    else
                    {
                        os__.writeSize(v__.Length);
                        for(int ix__ = 0; ix__ < v__.Length; ++ix__)
                        {
                            v__[ix__].write__(os__);
                        }
                    }
                }

                public static com.ec.service.DateTime[] read(IceInternal.BasicStream is__)
                {
                    com.ec.service.DateTime[] v__;
                    {
                        int szx__ = is__.readSize();
                        is__.checkFixedSeq(szx__, 12);
                        v__ = new com.ec.service.DateTime[szx__];
                        for(int ix__ = 0; ix__ < szx__; ++ix__)
                        {
                            v__[ix__].read__(is__);
                        }
                    }
                    return v__;
                }
            }

            public sealed class StringArrayHelper
            {
                public static void write(IceInternal.BasicStream os__, string[] v__)
                {
                    os__.writeStringSeq(v__);
                }

                public static string[] read(IceInternal.BasicStream is__)
                {
                    string[] v__;
                    v__ = is__.readStringSeq();
                    return v__;
                }
            }

            public sealed class ProductServicePrxHelper : Ice.ObjectPrxHelperBase, ProductServicePrx
            {
                #region Synchronous operations

                public bool addDirectory(int parentid, float tax, string dirName)
                {
                    return addDirectory(parentid, tax, dirName, null, false);
                }

                public bool addDirectory(int parentid, float tax, string dirName, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    return addDirectory(parentid, tax, dirName, context__, true);
                }

                private bool addDirectory(int parentid, float tax, string dirName, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            checkTwowayOnly__("addDirectory");
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            return del__.addDirectory(parentid, tax, dirName, context__);
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public com.ec.service.DateTime getCurrentDate()
                {
                    return getCurrentDate(null, false);
                }

                public com.ec.service.DateTime getCurrentDate(_System.Collections.Generic.Dictionary<string, string> context__)
                {
                    return getCurrentDate(context__, true);
                }

                private com.ec.service.DateTime getCurrentDate(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            checkTwowayOnly__("getCurrentDate");
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            return del__.getCurrentDate(context__);
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public com.ec.service.DateTime[] getTimes()
                {
                    return getTimes(null, false);
                }

                public com.ec.service.DateTime[] getTimes(_System.Collections.Generic.Dictionary<string, string> context__)
                {
                    return getTimes(context__, true);
                }

                private com.ec.service.DateTime[] getTimes(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            checkTwowayOnly__("getTimes");
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            return del__.getTimes(context__);
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public void printCurrentDate(com.ec.service.DateTime currentDate)
                {
                    printCurrentDate(currentDate, null, false);
                }

                public void printCurrentDate(com.ec.service.DateTime currentDate, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    printCurrentDate(currentDate, context__, true);
                }

                private void printCurrentDate(com.ec.service.DateTime currentDate, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            del__.printCurrentDate(currentDate, context__);
                            return;
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public void printString(string s)
                {
                    printString(s, null, false);
                }

                public void printString(string s, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    printString(s, context__, true);
                }

                private void printString(string s, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            del__.printString(s, context__);
                            return;
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public string[] queryBySql(string sql)
                {
                    return queryBySql(sql, null, false);
                }

                public string[] queryBySql(string sql, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    return queryBySql(sql, context__, true);
                }

                private string[] queryBySql(string sql, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            checkTwowayOnly__("queryBySql");
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            return del__.queryBySql(sql, context__);
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public string[] queryBySqlNotType(string sql)
                {
                    return queryBySqlNotType(sql, null, false);
                }

                public string[] queryBySqlNotType(string sql, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    return queryBySqlNotType(sql, context__, true);
                }

                private string[] queryBySqlNotType(string sql, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            checkTwowayOnly__("queryBySqlNotType");
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            return del__.queryBySqlNotType(sql, context__);
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                public bool updateDirectory(int id, string dirName, float tax)
                {
                    return updateDirectory(id, dirName, tax, null, false);
                }

                public bool updateDirectory(int id, string dirName, float tax, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    return updateDirectory(id, dirName, tax, context__, true);
                }

                private bool updateDirectory(int id, string dirName, float tax, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitContext__)
                {
                    if(explicitContext__ && context__ == null)
                    {
                        context__ = emptyContext_;
                    }
                    int cnt__ = 0;
                    while(true)
                    {
                        Ice.ObjectDel_ delBase__ = null;
                        try
                        {
                            checkTwowayOnly__("updateDirectory");
                            delBase__ = getDelegate__(false);
                            ProductServiceDel_ del__ = (ProductServiceDel_)delBase__;
                            return del__.updateDirectory(id, dirName, tax, context__);
                        }
                        catch(IceInternal.LocalExceptionWrapper ex__)
                        {
                            handleExceptionWrapper__(delBase__, ex__, null);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            handleException__(delBase__, ex__, null, ref cnt__);
                        }
                    }
                }

                #endregion

                #region Checked and unchecked cast operations

                public static ProductServicePrx checkedCast(Ice.ObjectPrx b)
                {
                    if(b == null)
                    {
                        return null;
                    }
                    ProductServicePrx r = b as ProductServicePrx;
                    if((r == null) && b.ice_isA("::com::ec::service::ProductService"))
                    {
                        ProductServicePrxHelper h = new ProductServicePrxHelper();
                        h.copyFrom__(b);
                        r = h;
                    }
                    return r;
                }

                public static ProductServicePrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
                {
                    if(b == null)
                    {
                        return null;
                    }
                    ProductServicePrx r = b as ProductServicePrx;
                    if((r == null) && b.ice_isA("::com::ec::service::ProductService", ctx))
                    {
                        ProductServicePrxHelper h = new ProductServicePrxHelper();
                        h.copyFrom__(b);
                        r = h;
                    }
                    return r;
                }

                public static ProductServicePrx checkedCast(Ice.ObjectPrx b, string f)
                {
                    if(b == null)
                    {
                        return null;
                    }
                    Ice.ObjectPrx bb = b.ice_facet(f);
                    try
                    {
                        if(bb.ice_isA("::com::ec::service::ProductService"))
                        {
                            ProductServicePrxHelper h = new ProductServicePrxHelper();
                            h.copyFrom__(bb);
                            return h;
                        }
                    }
                    catch(Ice.FacetNotExistException)
                    {
                    }
                    return null;
                }

                public static ProductServicePrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
                {
                    if(b == null)
                    {
                        return null;
                    }
                    Ice.ObjectPrx bb = b.ice_facet(f);
                    try
                    {
                        if(bb.ice_isA("::com::ec::service::ProductService", ctx))
                        {
                            ProductServicePrxHelper h = new ProductServicePrxHelper();
                            h.copyFrom__(bb);
                            return h;
                        }
                    }
                    catch(Ice.FacetNotExistException)
                    {
                    }
                    return null;
                }

                public static ProductServicePrx uncheckedCast(Ice.ObjectPrx b)
                {
                    if(b == null)
                    {
                        return null;
                    }
                    ProductServicePrx r = b as ProductServicePrx;
                    if(r == null)
                    {
                        ProductServicePrxHelper h = new ProductServicePrxHelper();
                        h.copyFrom__(b);
                        r = h;
                    }
                    return r;
                }

                public static ProductServicePrx uncheckedCast(Ice.ObjectPrx b, string f)
                {
                    if(b == null)
                    {
                        return null;
                    }
                    Ice.ObjectPrx bb = b.ice_facet(f);
                    ProductServicePrxHelper h = new ProductServicePrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }

                #endregion

                #region Marshaling support

                protected override Ice.ObjectDelM_ createDelegateM__()
                {
                    return new ProductServiceDelM_();
                }

                protected override Ice.ObjectDelD_ createDelegateD__()
                {
                    return new ProductServiceDelD_();
                }

                public static void write__(IceInternal.BasicStream os__, ProductServicePrx v__)
                {
                    os__.writeProxy(v__);
                }

                public static ProductServicePrx read__(IceInternal.BasicStream is__)
                {
                    Ice.ObjectPrx proxy = is__.readProxy();
                    if(proxy != null)
                    {
                        ProductServicePrxHelper result = new ProductServicePrxHelper();
                        result.copyFrom__(proxy);
                        return result;
                    }
                    return null;
                }

                #endregion
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public interface ProductServiceDel_ : Ice.ObjectDel_
            {
                com.ec.service.DateTime[] getTimes(_System.Collections.Generic.Dictionary<string, string> context__);

                com.ec.service.DateTime getCurrentDate(_System.Collections.Generic.Dictionary<string, string> context__);

                void printCurrentDate(com.ec.service.DateTime currentDate, _System.Collections.Generic.Dictionary<string, string> context__);

                void printString(string s, _System.Collections.Generic.Dictionary<string, string> context__);

                string[] queryBySql(string sql, _System.Collections.Generic.Dictionary<string, string> context__);

                string[] queryBySqlNotType(string sql, _System.Collections.Generic.Dictionary<string, string> context__);

                bool addDirectory(int parentid, float tax, string dirName, _System.Collections.Generic.Dictionary<string, string> context__);

                bool updateDirectory(int id, string dirName, float tax, _System.Collections.Generic.Dictionary<string, string> context__);
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public sealed class ProductServiceDelM_ : Ice.ObjectDelM_, ProductServiceDel_
            {
                public bool addDirectory(int parentid, float tax, string dirName, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("addDirectory", Ice.OperationMode.Normal, context__);
                    try
                    {
                        try
                        {
                            IceInternal.BasicStream os__ = og__.ostr();
                            os__.writeInt(parentid);
                            os__.writeFloat(tax);
                            os__.writeString(dirName);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            og__.abort(ex__);
                        }
                        bool ok__ = og__.invoke();
                        try
                        {
                            if(!ok__)
                            {
                                try
                                {
                                    og__.throwUserException();
                                }
                                catch(Ice.UserException ex)
                                {
                                    throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                }
                            }
                            IceInternal.BasicStream is__ = og__.istr();
                            is__.startReadEncaps();
                            bool ret__;
                            ret__ = is__.readBool();
                            is__.endReadEncaps();
                            return ret__;
                        }
                        catch(Ice.LocalException ex__)
                        {
                            throw new IceInternal.LocalExceptionWrapper(ex__, false);
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public com.ec.service.DateTime getCurrentDate(_System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("getCurrentDate", Ice.OperationMode.Normal, context__);
                    try
                    {
                        bool ok__ = og__.invoke();
                        try
                        {
                            if(!ok__)
                            {
                                try
                                {
                                    og__.throwUserException();
                                }
                                catch(Ice.UserException ex)
                                {
                                    throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                }
                            }
                            IceInternal.BasicStream is__ = og__.istr();
                            is__.startReadEncaps();
                            com.ec.service.DateTime ret__;
                            ret__ = new com.ec.service.DateTime();
                            ret__.read__(is__);
                            is__.endReadEncaps();
                            return ret__;
                        }
                        catch(Ice.LocalException ex__)
                        {
                            throw new IceInternal.LocalExceptionWrapper(ex__, false);
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public com.ec.service.DateTime[] getTimes(_System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("getTimes", Ice.OperationMode.Normal, context__);
                    try
                    {
                        bool ok__ = og__.invoke();
                        try
                        {
                            if(!ok__)
                            {
                                try
                                {
                                    og__.throwUserException();
                                }
                                catch(Ice.UserException ex)
                                {
                                    throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                }
                            }
                            IceInternal.BasicStream is__ = og__.istr();
                            is__.startReadEncaps();
                            com.ec.service.DateTime[] ret__;
                            {
                                int szx__ = is__.readSize();
                                is__.checkFixedSeq(szx__, 12);
                                ret__ = new com.ec.service.DateTime[szx__];
                                for(int ix__ = 0; ix__ < szx__; ++ix__)
                                {
                                    ret__[ix__].read__(is__);
                                }
                            }
                            is__.endReadEncaps();
                            return ret__;
                        }
                        catch(Ice.LocalException ex__)
                        {
                            throw new IceInternal.LocalExceptionWrapper(ex__, false);
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public void printCurrentDate(com.ec.service.DateTime currentDate, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("printCurrentDate", Ice.OperationMode.Normal, context__);
                    try
                    {
                        try
                        {
                            IceInternal.BasicStream os__ = og__.ostr();
                            currentDate.write__(os__);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            og__.abort(ex__);
                        }
                        bool ok__ = og__.invoke();
                        if(!og__.istr().isEmpty())
                        {
                            try
                            {
                                if(!ok__)
                                {
                                    try
                                    {
                                        og__.throwUserException();
                                    }
                                    catch(Ice.UserException ex)
                                    {
                                        throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                    }
                                }
                                og__.istr().skipEmptyEncaps();
                            }
                            catch(Ice.LocalException ex__)
                            {
                                throw new IceInternal.LocalExceptionWrapper(ex__, false);
                            }
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public void printString(string s, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("printString", Ice.OperationMode.Normal, context__);
                    try
                    {
                        try
                        {
                            IceInternal.BasicStream os__ = og__.ostr();
                            os__.writeString(s);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            og__.abort(ex__);
                        }
                        bool ok__ = og__.invoke();
                        if(!og__.istr().isEmpty())
                        {
                            try
                            {
                                if(!ok__)
                                {
                                    try
                                    {
                                        og__.throwUserException();
                                    }
                                    catch(Ice.UserException ex)
                                    {
                                        throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                    }
                                }
                                og__.istr().skipEmptyEncaps();
                            }
                            catch(Ice.LocalException ex__)
                            {
                                throw new IceInternal.LocalExceptionWrapper(ex__, false);
                            }
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public string[] queryBySql(string sql, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("queryBySql", Ice.OperationMode.Normal, context__);
                    try
                    {
                        try
                        {
                            IceInternal.BasicStream os__ = og__.ostr();
                            os__.writeString(sql);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            og__.abort(ex__);
                        }
                        bool ok__ = og__.invoke();
                        try
                        {
                            if(!ok__)
                            {
                                try
                                {
                                    og__.throwUserException();
                                }
                                catch(Ice.UserException ex)
                                {
                                    throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                }
                            }
                            IceInternal.BasicStream is__ = og__.istr();
                            is__.startReadEncaps();
                            string[] ret__;
                            ret__ = is__.readStringSeq();
                            is__.endReadEncaps();
                            return ret__;
                        }
                        catch(Ice.LocalException ex__)
                        {
                            throw new IceInternal.LocalExceptionWrapper(ex__, false);
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public string[] queryBySqlNotType(string sql, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("queryBySqlNotType", Ice.OperationMode.Normal, context__);
                    try
                    {
                        try
                        {
                            IceInternal.BasicStream os__ = og__.ostr();
                            os__.writeString(sql);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            og__.abort(ex__);
                        }
                        bool ok__ = og__.invoke();
                        try
                        {
                            if(!ok__)
                            {
                                try
                                {
                                    og__.throwUserException();
                                }
                                catch(Ice.UserException ex)
                                {
                                    throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                }
                            }
                            IceInternal.BasicStream is__ = og__.istr();
                            is__.startReadEncaps();
                            string[] ret__;
                            ret__ = is__.readStringSeq();
                            is__.endReadEncaps();
                            return ret__;
                        }
                        catch(Ice.LocalException ex__)
                        {
                            throw new IceInternal.LocalExceptionWrapper(ex__, false);
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }

                public bool updateDirectory(int id, string dirName, float tax, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    IceInternal.Outgoing og__ = handler__.getOutgoing("updateDirectory", Ice.OperationMode.Normal, context__);
                    try
                    {
                        try
                        {
                            IceInternal.BasicStream os__ = og__.ostr();
                            os__.writeInt(id);
                            os__.writeString(dirName);
                            os__.writeFloat(tax);
                        }
                        catch(Ice.LocalException ex__)
                        {
                            og__.abort(ex__);
                        }
                        bool ok__ = og__.invoke();
                        try
                        {
                            if(!ok__)
                            {
                                try
                                {
                                    og__.throwUserException();
                                }
                                catch(Ice.UserException ex)
                                {
                                    throw new Ice.UnknownUserException(ex.ice_name(), ex);
                                }
                            }
                            IceInternal.BasicStream is__ = og__.istr();
                            is__.startReadEncaps();
                            bool ret__;
                            ret__ = is__.readBool();
                            is__.endReadEncaps();
                            return ret__;
                        }
                        catch(Ice.LocalException ex__)
                        {
                            throw new IceInternal.LocalExceptionWrapper(ex__, false);
                        }
                    }
                    finally
                    {
                        handler__.reclaimOutgoing(og__);
                    }
                }
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public sealed class ProductServiceDelD_ : Ice.ObjectDelD_, ProductServiceDel_
            {
                public bool addDirectory(int parentid, float tax, string dirName, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "addDirectory", Ice.OperationMode.Normal, context__);
                    bool result__ = false;
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        result__ = servant__.addDirectory(parentid, tax, dirName, current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                    return result__;
                }

                public com.ec.service.DateTime getCurrentDate(_System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "getCurrentDate", Ice.OperationMode.Normal, context__);
                    com.ec.service.DateTime result__ = new com.ec.service.DateTime();
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        result__ = servant__.getCurrentDate(current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                    return result__;
                }

                public com.ec.service.DateTime[] getTimes(_System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "getTimes", Ice.OperationMode.Normal, context__);
                    com.ec.service.DateTime[] result__ = null;
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        result__ = servant__.getTimes(current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                    return result__;
                }

                public void printCurrentDate(com.ec.service.DateTime currentDate, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "printCurrentDate", Ice.OperationMode.Normal, context__);
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        servant__.printCurrentDate(currentDate, current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                }

                public void printString(string s, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "printString", Ice.OperationMode.Normal, context__);
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        servant__.printString(s, current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                }

                public string[] queryBySql(string sql, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "queryBySql", Ice.OperationMode.Normal, context__);
                    string[] result__ = null;
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        result__ = servant__.queryBySql(sql, current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                    return result__;
                }

                public string[] queryBySqlNotType(string sql, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "queryBySqlNotType", Ice.OperationMode.Normal, context__);
                    string[] result__ = null;
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        result__ = servant__.queryBySqlNotType(sql, current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                    return result__;
                }

                public bool updateDirectory(int id, string dirName, float tax, _System.Collections.Generic.Dictionary<string, string> context__)
                {
                    Ice.Current current__ = new Ice.Current();
                    initCurrent__(ref current__, "updateDirectory", Ice.OperationMode.Normal, context__);
                    bool result__ = false;
                    IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
                    {
                        ProductService servant__ = null;
                        try
                        {
                            servant__ = (ProductService)obj__;
                        }
                        catch(_System.InvalidCastException)
                        {
                            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                        }
                        result__ = servant__.updateDirectory(id, dirName, tax, current__);
                        return Ice.DispatchStatus.DispatchOK;
                    };
                    IceInternal.Direct direct__ = null;
                    try
                    {
                        direct__ = new IceInternal.Direct(current__, run__);
                        try
                        {
                            Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
                            _System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
                        }
                        finally
                        {
                            direct__.destroy();
                        }
                    }
                    catch(Ice.SystemException)
                    {
                        throw;
                    }
                    catch(System.Exception ex__)
                    {
                        IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
                    }
                    return result__;
                }
            }
        }
    }
}

namespace com
{
    namespace ec
    {
        namespace service
        {
            public abstract class ProductServiceDisp_ : Ice.ObjectImpl, ProductService
            {
                #region Slice operations

                public com.ec.service.DateTime[] getTimes()
                {
                    return getTimes(Ice.ObjectImpl.defaultCurrent);
                }

                public abstract com.ec.service.DateTime[] getTimes(Ice.Current current__);

                public com.ec.service.DateTime getCurrentDate()
                {
                    return getCurrentDate(Ice.ObjectImpl.defaultCurrent);
                }

                public abstract com.ec.service.DateTime getCurrentDate(Ice.Current current__);

                public void printCurrentDate(com.ec.service.DateTime currentDate)
                {
                    printCurrentDate(currentDate, Ice.ObjectImpl.defaultCurrent);
                }

                public abstract void printCurrentDate(com.ec.service.DateTime currentDate, Ice.Current current__);

                public void printString(string s)
                {
                    printString(s, Ice.ObjectImpl.defaultCurrent);
                }

                public abstract void printString(string s, Ice.Current current__);

                public string[] queryBySql(string sql)
                {
                    return queryBySql(sql, Ice.ObjectImpl.defaultCurrent);
                }

                public abstract string[] queryBySql(string sql, Ice.Current current__);

                public string[] queryBySqlNotType(string sql)
                {
                    return queryBySqlNotType(sql, Ice.ObjectImpl.defaultCurrent);
                }

                public abstract string[] queryBySqlNotType(string sql, Ice.Current current__);

                public bool addDirectory(int parentid, float tax, string dirName)
                {
                    return addDirectory(parentid, tax, dirName, Ice.ObjectImpl.defaultCurrent);
                }

                public abstract bool addDirectory(int parentid, float tax, string dirName, Ice.Current current__);

                public bool updateDirectory(int id, string dirName, float tax)
                {
                    return updateDirectory(id, dirName, tax, Ice.ObjectImpl.defaultCurrent);
                }

                public abstract bool updateDirectory(int id, string dirName, float tax, Ice.Current current__);

                #endregion

                #region Slice type-related members

                public static new string[] ids__ = 
                {
                    "::Ice::Object",
                    "::com::ec::service::ProductService"
                };

                public override bool ice_isA(string s)
                {
                    return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
                }

                public override bool ice_isA(string s, Ice.Current current__)
                {
                    return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
                }

                public override string[] ice_ids()
                {
                    return ids__;
                }

                public override string[] ice_ids(Ice.Current current__)
                {
                    return ids__;
                }

                public override string ice_id()
                {
                    return ids__[1];
                }

                public override string ice_id(Ice.Current current__)
                {
                    return ids__[1];
                }

                public static new string ice_staticId()
                {
                    return ids__[1];
                }

                #endregion

                #region Operation dispatch

                public static Ice.DispatchStatus getTimes___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    inS__.istr().skipEmptyEncaps();
                    IceInternal.BasicStream os__ = inS__.ostr();
                    com.ec.service.DateTime[] ret__ = obj__.getTimes(current__);
                    if(ret__ == null)
                    {
                        os__.writeSize(0);
                    }
                    else
                    {
                        os__.writeSize(ret__.Length);
                        for(int ix__ = 0; ix__ < ret__.Length; ++ix__)
                        {
                            ret__[ix__].write__(os__);
                        }
                    }
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus getCurrentDate___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    inS__.istr().skipEmptyEncaps();
                    IceInternal.BasicStream os__ = inS__.ostr();
                    com.ec.service.DateTime ret__ = obj__.getCurrentDate(current__);
                    ret__.write__(os__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus printCurrentDate___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    IceInternal.BasicStream is__ = inS__.istr();
                    is__.startReadEncaps();
                    com.ec.service.DateTime currentDate;
                    currentDate = new com.ec.service.DateTime();
                    currentDate.read__(is__);
                    is__.endReadEncaps();
                    obj__.printCurrentDate(currentDate, current__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus printString___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    IceInternal.BasicStream is__ = inS__.istr();
                    is__.startReadEncaps();
                    string s;
                    s = is__.readString();
                    is__.endReadEncaps();
                    obj__.printString(s, current__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus queryBySql___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    IceInternal.BasicStream is__ = inS__.istr();
                    is__.startReadEncaps();
                    string sql;
                    sql = is__.readString();
                    is__.endReadEncaps();
                    IceInternal.BasicStream os__ = inS__.ostr();
                    string[] ret__ = obj__.queryBySql(sql, current__);
                    os__.writeStringSeq(ret__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus queryBySqlNotType___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    IceInternal.BasicStream is__ = inS__.istr();
                    is__.startReadEncaps();
                    string sql;
                    sql = is__.readString();
                    is__.endReadEncaps();
                    IceInternal.BasicStream os__ = inS__.ostr();
                    string[] ret__ = obj__.queryBySqlNotType(sql, current__);
                    os__.writeStringSeq(ret__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus addDirectory___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    IceInternal.BasicStream is__ = inS__.istr();
                    is__.startReadEncaps();
                    int parentid;
                    parentid = is__.readInt();
                    float tax;
                    tax = is__.readFloat();
                    string dirName;
                    dirName = is__.readString();
                    is__.endReadEncaps();
                    IceInternal.BasicStream os__ = inS__.ostr();
                    bool ret__ = obj__.addDirectory(parentid, tax, dirName, current__);
                    os__.writeBool(ret__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                public static Ice.DispatchStatus updateDirectory___(ProductService obj__, IceInternal.Incoming inS__, Ice.Current current__)
                {
                    checkMode__(Ice.OperationMode.Normal, current__.mode);
                    IceInternal.BasicStream is__ = inS__.istr();
                    is__.startReadEncaps();
                    int id;
                    id = is__.readInt();
                    string dirName;
                    dirName = is__.readString();
                    float tax;
                    tax = is__.readFloat();
                    is__.endReadEncaps();
                    IceInternal.BasicStream os__ = inS__.ostr();
                    bool ret__ = obj__.updateDirectory(id, dirName, tax, current__);
                    os__.writeBool(ret__);
                    return Ice.DispatchStatus.DispatchOK;
                }

                private static string[] all__ =
                {
                    "addDirectory",
                    "getCurrentDate",
                    "getTimes",
                    "ice_id",
                    "ice_ids",
                    "ice_isA",
                    "ice_ping",
                    "printCurrentDate",
                    "printString",
                    "queryBySql",
                    "queryBySqlNotType",
                    "updateDirectory"
                };

                public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
                {
                    int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
                    if(pos < 0)
                    {
                        throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                    }

                    switch(pos)
                    {
                        case 0:
                        {
                            return addDirectory___(this, inS__, current__);
                        }
                        case 1:
                        {
                            return getCurrentDate___(this, inS__, current__);
                        }
                        case 2:
                        {
                            return getTimes___(this, inS__, current__);
                        }
                        case 3:
                        {
                            return ice_id___(this, inS__, current__);
                        }
                        case 4:
                        {
                            return ice_ids___(this, inS__, current__);
                        }
                        case 5:
                        {
                            return ice_isA___(this, inS__, current__);
                        }
                        case 6:
                        {
                            return ice_ping___(this, inS__, current__);
                        }
                        case 7:
                        {
                            return printCurrentDate___(this, inS__, current__);
                        }
                        case 8:
                        {
                            return printString___(this, inS__, current__);
                        }
                        case 9:
                        {
                            return queryBySql___(this, inS__, current__);
                        }
                        case 10:
                        {
                            return queryBySqlNotType___(this, inS__, current__);
                        }
                        case 11:
                        {
                            return updateDirectory___(this, inS__, current__);
                        }
                    }

                    _System.Diagnostics.Debug.Assert(false);
                    throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
                }

                #endregion

                #region Marshaling support

                public override void write__(IceInternal.BasicStream os__)
                {
                    os__.writeTypeId(ice_staticId());
                    os__.startWriteSlice();
                    os__.endWriteSlice();
                    base.write__(os__);
                }

                public override void read__(IceInternal.BasicStream is__, bool rid__)
                {
                    if(rid__)
                    {
                        /* string myId = */ is__.readTypeId();
                    }
                    is__.startReadSlice();
                    is__.endReadSlice();
                    base.read__(is__, true);
                }

                public override void write__(Ice.OutputStream outS__)
                {
                    Ice.MarshalException ex = new Ice.MarshalException();
                    ex.reason = "type com::ec::service::ProductService was not generated with stream support";
                    throw ex;
                }

                public override void read__(Ice.InputStream inS__, bool rid__)
                {
                    Ice.MarshalException ex = new Ice.MarshalException();
                    ex.reason = "type com::ec::service::ProductService was not generated with stream support";
                    throw ex;
                }

                #endregion
            }
        }
    }
}
